;;;; -*- Mode: Lisp; Syntax: Common-Lisp; Package: CL-USER; Base: 10 -*-
;;; Regex test case testinput2 from PCRE.
;;;
;;; This file is automatically generated from PCRE's test data with
;;; Perl 5.008004 at 2004-05-24 17:48:50 UTC.
;;;
;;; See: http://www.pcre.org/ for PCRE, Perl Compatible Regex.
;;;
;

;;;; testinput2/4: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/4"
  "abc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput2/5: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/5"
  "abc"
  "defabc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput2/6: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/6"
  "abc"
  "Aabc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput2/7: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/7"
  "abc"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput2/8: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/8"
  "abc"
  "Adefabc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput2/9: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/9"
  "abc"
  "ABC"
  '(:single-line nil)
  nil
 )

;;;; testinput2/12: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/12"
  "^abc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput2/13: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/13"
  "^abc"
  "Aabc"
  '(:single-line nil)
  nil
 )

;;;; testinput2/14: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/14"
  "^abc"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput2/15: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/15"
  "^abc"
  "defabc"
  '(:single-line nil)
  nil
 )

;;;; testinput2/16: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/16"
  "^abc"
  "Adefabc"
  '(:single-line nil)
  nil
 )

;;;; testinput2/27: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/27"
  "^abc$"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput2/28: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/28"
  "^abc$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput2/29: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/29"
  "^abc$"
  (backslash "def\\nabc")
  '(:single-line nil)
  nil
 )

;;;; testinput2/58: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/58"
  "cat|dog|elephant"
  "this sentence eventually mentions a cat"
  '(:single-line nil)
  (list "cat") )

;;;; testinput2/59: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/59"
  "cat|dog|elephant"
  "this sentences rambles on and on for a while and then reaches elephant"
  '(:single-line nil)
  (list "elephant") )

;;;; testinput2/62: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/62"
  "cat|dog|elephant"
  "this sentence eventually mentions a cat"
  '(:single-line nil)
  (list "cat") )

;;;; testinput2/63: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/63"
  "cat|dog|elephant"
  "this sentences rambles on and on for a while and then reaches elephant"
  '(:single-line nil)
  (list "elephant") )

;;;; testinput2/66: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/66"
  "cat|dog|elephant"
  "this sentence eventually mentions a CAT cat"
  '(:ignore-case t :single-line nil)
  (list "CAT") )

;;;; testinput2/67: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/67"
  "cat|dog|elephant"
  "this sentences rambles on and on for a while to elephant ElePhant"
  '(:ignore-case t :single-line nil)
  (list "elephant") )

;;;; testinput2/80: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-2/80"
  "(a)(b)(c)\\2"
  "abcb"
  '(:single-line nil)
  (list
    "abcb"
    "a"
    "b"
    "c" ) )

;;;; testinput2/81: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-2/81"
  "(a)(b)(c)\\2"
  "O0abcb"
  '(:single-line nil)
  (list
    "abcb"
    "a"
    "b"
    "c" ) )

;;;; testinput2/82: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-2/82"
  "(a)(b)(c)\\2"
  "O3abcb"
  '(:single-line nil)
  (list
    "abcb"
    "a"
    "b"
    "c" ) )

;;;; testinput2/83: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-2/83"
  "(a)(b)(c)\\2"
  "O6abcb"
  '(:single-line nil)
  (list
    "abcb"
    "a"
    "b"
    "c" ) )

;;;; testinput2/84: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-2/84"
  "(a)(b)(c)\\2"
  "O9abcb"
  '(:single-line nil)
  (list
    "abcb"
    "a"
    "b"
    "c" ) )

;;;; testinput2/85: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-2/85"
  "(a)(b)(c)\\2"
  "O12abcb"
  '(:single-line nil)
  (list
    "abcb"
    "a"
    "b"
    "c" ) )

;;;; testinput2/88: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-2/88"
  "(a)bc|(a)(b)\\2"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "a" ) )

;;;; testinput2/89: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-2/89"
  "(a)bc|(a)(b)\\2"
  "O0abc"
  '(:single-line nil)
  (list
    "abc"
    "a" ) )

;;;; testinput2/90: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-2/90"
  "(a)bc|(a)(b)\\2"
  "O3abc"
  '(:single-line nil)
  (list
    "abc"
    "a" ) )

;;;; testinput2/91: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-2/91"
  "(a)bc|(a)(b)\\2"
  "O6abc"
  '(:single-line nil)
  (list
    "abc"
    "a" ) )

;;;; testinput2/92: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-2/92"
  "(a)bc|(a)(b)\\2"
  "aba"
  '(:single-line nil)
  (list
    "aba"
    nil
    "a"
    "b" ) )

;;;; testinput2/93: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-2/93"
  "(a)bc|(a)(b)\\2"
  "O0aba"
  '(:single-line nil)
  (list
    "aba"
    nil
    "a"
    "b" ) )

;;;; testinput2/94: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-2/94"
  "(a)bc|(a)(b)\\2"
  "O3aba"
  '(:single-line nil)
  (list
    "aba"
    nil
    "a"
    "b" ) )

;;;; testinput2/95: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-2/95"
  "(a)bc|(a)(b)\\2"
  "O6aba"
  '(:single-line nil)
  (list
    "aba"
    nil
    "a"
    "b" ) )

;;;; testinput2/96: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-2/96"
  "(a)bc|(a)(b)\\2"
  "O9aba"
  '(:single-line nil)
  (list
    "aba"
    nil
    "a"
    "b" ) )

;;;; testinput2/97: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-2/97"
  "(a)bc|(a)(b)\\2"
  "O12aba"
  '(:single-line nil)
  (list
    "aba"
    nil
    "a"
    "b" ) )

;;;; testinput2/100: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/100"
  "abc$"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput2/101: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/101"
  "abc$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput2/102: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/102"
  "abc$"
  "abc
"
  '(:single-line nil)
  (list "abc") )

;;;; testinput2/103: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/103"
  "abc$"
  (backslash "abc\\ndef")
  '(:single-line nil)
  nil
 )

;;;; testinput2/108: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/108"
  "the quick brown fox"
  "the quick brown fox"
  '(:single-line nil)
  (list "the quick brown fox") )

;;;; testinput2/109: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/109"
  "the quick brown fox"
  "this is a line with the quick brown fox"
  '(:single-line nil)
  (list "the quick brown fox") )

;;;; testinput2/112: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/112"
  "the quick brown fox"
  "the quick brown fox"
  '(:single-line nil)
  (list "the quick brown fox") )

;;;; testinput2/113: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/113"
  "the quick brown fox"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput2/114: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/114"
  "the quick brown fox"
  "this is a line with the quick brown fox"
  '(:single-line nil)
  (list "the quick brown fox") )

;;;; testinput2/119: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/119"
  "^abc|def"
  "abcdef"
  '(:single-line nil)
  (list "abc") )

;;;; testinput2/120: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/120"
  "^abc|def"
  "abcdefB"
  '(:single-line nil)
  (list "abc") )

;;;; testinput2/123: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-2/123"
  ".*((abc)$|(def))"
  "defabc"
  '(:single-line nil)
  (list
    "defabc"
    "abc"
    "abc" ) )

;;;; testinput2/124: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-2/124"
  ".*((abc)$|(def))"
  "Zdefabc"
  '(:single-line nil)
  (list
    "Zdefabc"
    "abc"
    "abc" ) )

;;;; testinput2/127: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/127"
  "abc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput2/128: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/128"
  "abc"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput2/131: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/131"
  "^abc|def"
  "abcdef"
  '(:single-line nil)
  (list "abc") )

;;;; testinput2/132: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/132"
  "^abc|def"
  "abcdefB"
  '(:single-line nil)
  (list "abc") )

;;;; testinput2/135: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-2/135"
  ".*((abc)$|(def))"
  "defabc"
  '(:single-line nil)
  (list
    "defabc"
    "abc"
    "abc" ) )

;;;; testinput2/136: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-2/136"
  ".*((abc)$|(def))"
  "Zdefabc"
  '(:single-line nil)
  (list
    "Zdefabc"
    "abc"
    "abc" ) )

;;;; testinput2/139: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/139"
  "the quick brown fox"
  "the quick brown fox"
  '(:single-line nil)
  (list "the quick brown fox") )

;;;; testinput2/140: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/140"
  "the quick brown fox"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput2/141: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/141"
  "the quick brown fox"
  "The Quick Brown Fox"
  '(:single-line nil)
  nil
 )

;;;; testinput2/144: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/144"
  "the quick brown fox"
  "the quick brown fox"
  '(:ignore-case t :single-line nil)
  (list "the quick brown fox") )

;;;; testinput2/145: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/145"
  "the quick brown fox"
  "The Quick Brown Fox"
  '(:ignore-case t :single-line nil)
  (list "The Quick Brown Fox") )

;;;; testinput2/148: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/148"
  "abc.def"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput2/149: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/149"
  "abc.def"
  (backslash "abc\\ndef")
  '(:single-line nil)
  nil
 )

;;;; testinput2/152: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/152"
  "abc$"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput2/153: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/153"
  "abc$"
  "abc
"
  '(:single-line nil)
  (list "abc") )

;;;; testinput2/158: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/158"
  "(abc\\1)"
  "abc"
  '(:single-line nil)
  nil
 )

;;;; testinput2/165: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/165"
  "[^aeiou ]{3,}"
  "co-processors, and for"
  '(:single-line nil)
  (list "-pr") )

;;;; testinput2/168: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/168"
  "<.*>"
  "abc<def>ghi<klm>nop"
  '(:single-line nil)
  (list "<def>ghi<klm>") )

;;;; testinput2/171: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/171"
  "<.*?>"
  "abc<def>ghi<klm>nop"
  '(:single-line nil)
  (list "<def>") )

;;;; testinput2/174: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/174"
  "<.*>"
  "abc<def>ghi<klm>nop"
  '(:single-line nil)
  (list "<def>ghi<klm>") )

;;;; testinput2/177: 
;;;
;;;    
;
(test-case
  "pcre-2/177"
  "(?U)<.*>"
  "abc<def>ghi<klm>nop"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/180: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/180"
  "<.*?>"
  "abc<def>ghi<klm>nop"
  '(:single-line nil)
  (list "<def>") )

;;;; testinput2/183: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/183"
  "={3,}"
  "abc========def"
  '(:single-line nil)
  (list "========") )

;;;; testinput2/186: 
;;;
;;;    
;
(test-case
  "pcre-2/186"
  "(?U)={3,}?"
  "abc========def"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/189: 
;;;
;;;    
;
(test-case
  "pcre-2/189"
  "(?<!bar|cattle)foo"
  "foo"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/190: 
;;;
;;;    
;
(test-case
  "pcre-2/190"
  "(?<!bar|cattle)foo"
  "catfoo"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/191: 
;;;
;;;    
;
(test-case
  "pcre-2/191"
  "(?<!bar|cattle)foo"
  "*** Failers"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/192: 
;;;
;;;    
;
(test-case
  "pcre-2/192"
  "(?<!bar|cattle)foo"
  "the barfoo"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/193: 
;;;
;;;    
;
(test-case
  "pcre-2/193"
  "(?<!bar|cattle)foo"
  "and cattlefoo"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/242: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/242"
  "a$"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; testinput2/243: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/243"
  "a$"
  "a
"
  '(:single-line nil)
  (list "a") )

;;;; testinput2/244: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/244"
  "a$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput2/245: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/245"
  "a$"
  "Za"
  '(:single-line nil)
  (list "a") )

;;;; testinput2/246: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/246"
  "a$"
  "Za
"
  '(:single-line nil)
  (list "a") )

;;;; testinput2/249: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/249"
  "a$"
  "a"
  '(:multiple-lines t :single-line nil)
  (list "a") )

;;;; testinput2/250: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/250"
  "a$"
  "a
"
  '(:multiple-lines t :single-line nil)
  (list "a") )

;;;; testinput2/251: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/251"
  "a$"
  "Za
"
  '(:multiple-lines t :single-line nil)
  (list "a") )

;;;; testinput2/252: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/252"
  "a$"
  "*** Failers"
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput2/253: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/253"
  "a$"
  "Za"
  '(:multiple-lines t :single-line nil)
  (list "a") )

;;;; testinput2/260: 
;;;
;;;    
;
(test-case
  "pcre-2/260"
  "^((a+)(?U)([ab]+)(?-U)([bc]+)(\\w*))"
  "aaaaabbbbbcccccdef"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/271: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/271"
  "(?>^abc)"
  "abc"
  '(:multiple-lines t :single-line nil)
  (list "abc") )

;;;; testinput2/272: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/272"
  "(?>^abc)"
  (backslash "def\\nabc")
  '(:multiple-lines t :single-line nil)
  (list "abc") )

;;;; testinput2/273: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/273"
  "(?>^abc)"
  "*** Failers"
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput2/274: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/274"
  "(?>^abc)"
  "defabc"
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput2/285: 
;;;
;;;    
;
(test-case
  "pcre-2/285"
  "(?<=bullock|donkey)-cart"
  "the bullock-cart"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/286: 
;;;
;;;    
;
(test-case
  "pcre-2/286"
  "(?<=bullock|donkey)-cart"
  "a donkey-cart race"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/287: 
;;;
;;;    
;
(test-case
  "pcre-2/287"
  "(?<=bullock|donkey)-cart"
  "*** Failers"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/288: 
;;;
;;;    
;
(test-case
  "pcre-2/288"
  "(?<=bullock|donkey)-cart"
  "cart"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/289: 
;;;
;;;    
;
(test-case
  "pcre-2/289"
  "(?<=bullock|donkey)-cart"
  "horse-and-cart"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/294: 
;;;
;;;    
;
(test-case
  "pcre-2/294"
  "(?>.*)(?<=(abcd)|(xyz))"
  "alphabetabcd"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/295: 
;;;
;;;    
;
(test-case
  "pcre-2/295"
  "(?>.*)(?<=(abcd)|(xyz))"
  "endingxyz"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/298: 
;;;
;;;    
;
(test-case
  "pcre-2/298"
  "(?<=ab(?i)x(?-i)y|(?i)z|b)ZZ"
  "abxyZZ"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/299: 
;;;
;;;    
;
(test-case
  "pcre-2/299"
  "(?<=ab(?i)x(?-i)y|(?i)z|b)ZZ"
  "abXyZZ"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/300: 
;;;
;;;    
;
(test-case
  "pcre-2/300"
  "(?<=ab(?i)x(?-i)y|(?i)z|b)ZZ"
  "ZZZ"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/301: 
;;;
;;;    
;
(test-case
  "pcre-2/301"
  "(?<=ab(?i)x(?-i)y|(?i)z|b)ZZ"
  "zZZ"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/302: 
;;;
;;;    
;
(test-case
  "pcre-2/302"
  "(?<=ab(?i)x(?-i)y|(?i)z|b)ZZ"
  "bZZ"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/303: 
;;;
;;;    
;
(test-case
  "pcre-2/303"
  "(?<=ab(?i)x(?-i)y|(?i)z|b)ZZ"
  "BZZ"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/304: 
;;;
;;;    
;
(test-case
  "pcre-2/304"
  "(?<=ab(?i)x(?-i)y|(?i)z|b)ZZ"
  "*** Failers"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/305: 
;;;
;;;    
;
(test-case
  "pcre-2/305"
  "(?<=ab(?i)x(?-i)y|(?i)z|b)ZZ"
  "ZZ"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/306: 
;;;
;;;    
;
(test-case
  "pcre-2/306"
  "(?<=ab(?i)x(?-i)y|(?i)z|b)ZZ"
  "abXYZZ"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/307: 
;;;
;;;    
;
(test-case
  "pcre-2/307"
  "(?<=ab(?i)x(?-i)y|(?i)z|b)ZZ"
  "zzz"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/308: 
;;;
;;;    
;
(test-case
  "pcre-2/308"
  "(?<=ab(?i)x(?-i)y|(?i)z|b)ZZ"
  "bzz"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/311: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/311"
  "(?<!(foo)a)bar"
  "bar"
  '(:single-line nil)
  (list "bar") )

;;;; testinput2/312: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-2/312"
  "(?<!(foo)a)bar"
  "foobbar"
  '(:single-line nil)
  (list
    "bar"
    "foo" ) )

;;;; testinput2/313: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/313"
  "(?<!(foo)a)bar"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput2/314: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/314"
  "(?<!(foo)a)bar"
  "fooabar"
  '(:single-line nil)
  nil
 )

;;;; testinput2/319: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/319"
  "^(a)?(?(1)a|b)+$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput2/320: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/320"
  "^(a)?(?(1)a|b)+$"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput2/325: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-2/325"
  "^(a\\1?){4}$"
  "aaaaaa"
  '(:single-line nil)
  (list
    "aaaaaa"
    "aa" ) )

;;;; testinput2/402: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-2/402"
  "(a)bc(d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "a"
    "d" ) )

;;;; testinput2/403: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-2/403"
  "(a)bc(d)"
  "abcdC2"
  '(:single-line nil)
  (list
    "abcd"
    "a"
    "d" ) )

;;;; testinput2/404: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-2/404"
  "(a)bc(d)"
  "abcdC5"
  '(:single-line nil)
  (list
    "abcd"
    "a"
    "d" ) )

;;;; testinput2/407: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-2/407"
  "(.{20})"
  "abcdefghijklmnopqrstuvwxyz"
  '(:single-line nil)
  (list
    "abcdefghijklmnopqrst"
    "abcdefghijklmnopqrst" ) )

;;;; testinput2/408: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-2/408"
  "(.{20})"
  "abcdefghijklmnopqrstuvwxyzC1"
  '(:single-line nil)
  (list
    "abcdefghijklmnopqrst"
    "abcdefghijklmnopqrst" ) )

;;;; testinput2/409: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-2/409"
  "(.{20})"
  "abcdefghijklmnopqrstuvwxyzG1"
  '(:single-line nil)
  (list
    "abcdefghijklmnopqrst"
    "abcdefghijklmnopqrst" ) )

;;;; testinput2/412: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-2/412"
  "(.{15})"
  "abcdefghijklmnopqrstuvwxyz"
  '(:single-line nil)
  (list
    "abcdefghijklmno"
    "abcdefghijklmno" ) )

;;;; testinput2/413: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-2/413"
  "(.{15})"
  "abcdefghijklmnopqrstuvwxyzC1G1"
  '(:single-line nil)
  (list
    "abcdefghijklmno"
    "abcdefghijklmno" ) )

;;;; testinput2/416: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-2/416"
  "(.{16})"
  "abcdefghijklmnopqrstuvwxyz"
  '(:single-line nil)
  (list
    "abcdefghijklmnop"
    "abcdefghijklmnop" ) )

;;;; testinput2/417: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-2/417"
  "(.{16})"
  "abcdefghijklmnopqrstuvwxyzC1G1"
  '(:single-line nil)
  (list
    "abcdefghijklmnop"
    "abcdefghijklmnop" ) )

;;;; testinput2/420: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-2/420"
  "^(a|(bc))de(f)"
  "adefG1G2G3G4"
  '(:single-line nil)
  (list
    "adef"
    "a"
    nil
    "f" ) )

;;;; testinput2/421: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-2/421"
  "^(a|(bc))de(f)"
  "bcdefG1G2G3G4"
  '(:single-line nil)
  (list
    "bcdef"
    "bc"
    "bc"
    "f" ) )

;;;; testinput2/422: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-2/422"
  "^(a|(bc))de(f)"
  "adefghijkC0"
  '(:single-line nil)
  (list
    "adef"
    "a"
    nil
    "f" ) )

;;;; testinput2/425: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/425"
  "^abc\\00def"
  (backslash "abc\\u0000defc0")
  '(:single-line nil)
  (list (backslash "abc\\u0000def")) )

;;;; testinput2/444: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/444"
  "\\Biss\\B"
  "Mississippi"
  '(:single-line nil)
  (list "iss") )

;;;; testinput2/447: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/447"
  "\\Biss\\B"
  "Mississippi"
  '(:single-line nil)
  (list "iss") )

;;;; testinput2/450: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/450"
  "iss"
  "Mississippi"
  '(:single-line nil)
  (list "iss") )

;;;; testinput2/453: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/453"
  "\\Biss\\B"
  "Mississippi"
  '(:single-line nil)
  (list "iss") )

;;;; testinput2/456: 
;;;
;;;    
;
(test-case/g
  "pcre-2/456"
  "\\Biss\\B"
  "Mississippi"
  '(:single-line nil)
  (list "iss"
        "iss" )
    "" )

;;;; testinput2/457: 
;;;
;;;    
;
(test-case/g
  "pcre-2/457"
  "\\Biss\\B"
  "*** Failers"
  '(:single-line nil)
  (list)
    "" )

;;;; testinput2/458: 
;;;
;;;    
;
(test-case/g
  "pcre-2/458"
  "\\Biss\\B"
  "MississippiA"
  '(:single-line nil)
  (list "iss"
        "iss" )
    "" )

;;;; testinput2/461: 
;;;
;;;    
;
(test-case/g
  "pcre-2/461"
  "(?<=[Ms])iss"
  "Mississippi"
  '(:single-line nil)
  (list "iss"
        "iss" )
    "" )

;;;; testinput2/464: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/464"
  "(?<=[Ms])iss"
  "Mississippi"
  '(:single-line nil)
  (list "iss") )

;;;; testinput2/467: 
;;;
;;;    
;
(test-case/g
  "pcre-2/467"
  "^iss"
  "ississippi"
  '(:single-line nil)
  (list "iss")
    "" )

;;;; testinput2/470: 
;;;
;;;    
;
(test-case/g
  "pcre-2/470"
  ".*iss"
  (backslash "abciss\\nxyzisspqr")
  '(:single-line nil)
  (list "abciss"
        "xyziss" )
    "" )

;;;; testinput2/473: 
;;;
;;;    
;
(test-case/g
  "pcre-2/473"
  ".i."
  "Mississippi"
  '(:single-line nil)
  (list "Mis"
        "sis"
        "sip" )
    "" )

;;;; testinput2/474: 
;;;
;;;    
;
(test-case/g
  "pcre-2/474"
  ".i."
  "MississippiA"
  '(:single-line nil)
  (list "Mis"
        "sis"
        "sip"
        "piA" )
    "" )

;;;; testinput2/475: 
;;;
;;;    
;
(test-case/g
  "pcre-2/475"
  ".i."
  "Missouri river"
  '(:single-line nil)
  (list "Mis"
        "ri "
        "riv" )
    "" )

;;;; testinput2/476: 
;;;
;;;    
;
(test-case/g
  "pcre-2/476"
  ".i."
  "Missouri riverA"
  '(:single-line nil)
  (list "Mis"
        "ri "
        "riv" )
    "" )

;;;; testinput2/479: 
;;;
;;;    
;
(test-case/g
  "pcre-2/479"
  "^.is"
  "Mississippi"
  '(:single-line nil)
  (list "Mis")
    "" )

;;;; testinput2/482: 
;;;
;;;    
;
(test-case/g
  "pcre-2/482"
  "^ab\\n"
  (backslash "ab\\nab\\ncd")
  '(:single-line nil)
  (list "ab
")
    "" )

;;;; testinput2/485: 
;;;
;;;    
;
(test-case/g
  "pcre-2/485"
  "^ab\\n"
  (backslash "ab\\nab\\ncd")
  '(:multiple-lines t :single-line nil)
  (list "ab
"
        "ab
" )
    "" )

;;;; testinput2/570: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/570"
  "a?b?"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; testinput2/571: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/571"
  "a?b?"
  "b"
  '(:single-line nil)
  (list "b") )

;;;; testinput2/572: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/572"
  "a?b?"
  "ab"
  '(:single-line nil)
  (list "ab") )

;;;; testinput2/573: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/573"
  "a?b?"
  ""
  '(:single-line nil)
  (list "") )

;;;; testinput2/574: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/574"
  "a?b?"
  "*** Failers"
  '(:single-line nil)
  (list "") )

;;;; testinput2/575: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/575"
  "a?b?"
  ""
  '(:single-line nil)
  (list "") )

;;;; testinput2/578: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/578"
  "|-"
  "abcd"
  '(:single-line nil)
  (list "") )

;;;; testinput2/579: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/579"
  "|-"
  "-abc"
  '(:single-line nil)
  (list "") )

;;;; testinput2/580: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/580"
  "|-"
  ""
  '(:single-line nil)
  (list "") )

;;;; testinput2/581: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/581"
  "|-"
  "*** Failers"
  '(:single-line nil)
  (list "") )

;;;; testinput2/582: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/582"
  "|-"
  ""
  '(:single-line nil)
  (list "") )

;;;; testinput2/585: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-2/585"
  "a*(b+)(z)(z)"
  "aaaabbbbzzzz"
  '(:single-line nil)
  (list
    "aaaabbbbzz"
    "bbbb"
    "z"
    "z" ) )

;;;; testinput2/586: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-2/586"
  "a*(b+)(z)(z)"
  "aaaabbbbzzzzO0"
  '(:single-line nil)
  (list
    "aaaabbbbzz"
    "bbbb"
    "z"
    "z" ) )

;;;; testinput2/587: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-2/587"
  "a*(b+)(z)(z)"
  "aaaabbbbzzzzO1"
  '(:single-line nil)
  (list
    "aaaabbbbzz"
    "bbbb"
    "z"
    "z" ) )

;;;; testinput2/588: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-2/588"
  "a*(b+)(z)(z)"
  "aaaabbbbzzzzO2"
  '(:single-line nil)
  (list
    "aaaabbbbzz"
    "bbbb"
    "z"
    "z" ) )

;;;; testinput2/589: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-2/589"
  "a*(b+)(z)(z)"
  "aaaabbbbzzzzO3"
  '(:single-line nil)
  (list
    "aaaabbbbzz"
    "bbbb"
    "z"
    "z" ) )

;;;; testinput2/590: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-2/590"
  "a*(b+)(z)(z)"
  "aaaabbbbzzzzO4"
  '(:single-line nil)
  (list
    "aaaabbbbzz"
    "bbbb"
    "z"
    "z" ) )

;;;; testinput2/591: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-2/591"
  "a*(b+)(z)(z)"
  "aaaabbbbzzzzO5"
  '(:single-line nil)
  (list
    "aaaabbbbzz"
    "bbbb"
    "z"
    "z" ) )

;;;; testinput2/603: 
;;;
;;;    
;
(test-case
  "pcre-2/603"
  (backslash "\\(             # ( at start\\n  (?:           # Non-capturing bracket\\n  (?>[^()]+)    # Either a sequence of non-brackets (no backtracking)\\n  |             # Or\\n  (?R)          # Recurse - i.e. nested bracketed string\\n  )*            # Zero or more contents\\n  \\)            # Closing )\\n  ")
  "(abcd)"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/604: 
;;;
;;;    
;
(test-case
  "pcre-2/604"
  (backslash "\\(             # ( at start\\n  (?:           # Non-capturing bracket\\n  (?>[^()]+)    # Either a sequence of non-brackets (no backtracking)\\n  |             # Or\\n  (?R)          # Recurse - i.e. nested bracketed string\\n  )*            # Zero or more contents\\n  \\)            # Closing )\\n  ")
  "(abcd)xyz"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/605: 
;;;
;;;    
;
(test-case
  "pcre-2/605"
  (backslash "\\(             # ( at start\\n  (?:           # Non-capturing bracket\\n  (?>[^()]+)    # Either a sequence of non-brackets (no backtracking)\\n  |             # Or\\n  (?R)          # Recurse - i.e. nested bracketed string\\n  )*            # Zero or more contents\\n  \\)            # Closing )\\n  ")
  "xyz(abcd)"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/606: 
;;;
;;;    
;
(test-case
  "pcre-2/606"
  (backslash "\\(             # ( at start\\n  (?:           # Non-capturing bracket\\n  (?>[^()]+)    # Either a sequence of non-brackets (no backtracking)\\n  |             # Or\\n  (?R)          # Recurse - i.e. nested bracketed string\\n  )*            # Zero or more contents\\n  \\)            # Closing )\\n  ")
  "(ab(xy)cd)pqr"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/607: 
;;;
;;;    
;
(test-case
  "pcre-2/607"
  (backslash "\\(             # ( at start\\n  (?:           # Non-capturing bracket\\n  (?>[^()]+)    # Either a sequence of non-brackets (no backtracking)\\n  |             # Or\\n  (?R)          # Recurse - i.e. nested bracketed string\\n  )*            # Zero or more contents\\n  \\)            # Closing )\\n  ")
  "(ab(xycd)pqr"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/608: 
;;;
;;;    
;
(test-case
  "pcre-2/608"
  (backslash "\\(             # ( at start\\n  (?:           # Non-capturing bracket\\n  (?>[^()]+)    # Either a sequence of non-brackets (no backtracking)\\n  |             # Or\\n  (?R)          # Recurse - i.e. nested bracketed string\\n  )*            # Zero or more contents\\n  \\)            # Closing )\\n  ")
  "() abc ()"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/609: 
;;;
;;;    
;
(test-case
  "pcre-2/609"
  (backslash "\\(             # ( at start\\n  (?:           # Non-capturing bracket\\n  (?>[^()]+)    # Either a sequence of non-brackets (no backtracking)\\n  |             # Or\\n  (?R)          # Recurse - i.e. nested bracketed string\\n  )*            # Zero or more contents\\n  \\)            # Closing )\\n  ")
  "12(abcde(fsh)xyz(foo(bar))lmno)89"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/610: 
;;;
;;;    
;
(test-case
  "pcre-2/610"
  (backslash "\\(             # ( at start\\n  (?:           # Non-capturing bracket\\n  (?>[^()]+)    # Either a sequence of non-brackets (no backtracking)\\n  |             # Or\\n  (?R)          # Recurse - i.e. nested bracketed string\\n  )*            # Zero or more contents\\n  \\)            # Closing )\\n  ")
  "*** Failers"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/611: 
;;;
;;;    
;
(test-case
  "pcre-2/611"
  (backslash "\\(             # ( at start\\n  (?:           # Non-capturing bracket\\n  (?>[^()]+)    # Either a sequence of non-brackets (no backtracking)\\n  |             # Or\\n  (?R)          # Recurse - i.e. nested bracketed string\\n  )*            # Zero or more contents\\n  \\)            # Closing )\\n  ")
  "abcd"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/612: 
;;;
;;;    
;
(test-case
  "pcre-2/612"
  (backslash "\\(             # ( at start\\n  (?:           # Non-capturing bracket\\n  (?>[^()]+)    # Either a sequence of non-brackets (no backtracking)\\n  |             # Or\\n  (?R)          # Recurse - i.e. nested bracketed string\\n  )*            # Zero or more contents\\n  \\)            # Closing )\\n  ")
  "abcd)"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/613: 
;;;
;;;    
;
(test-case
  "pcre-2/613"
  (backslash "\\(             # ( at start\\n  (?:           # Non-capturing bracket\\n  (?>[^()]+)    # Either a sequence of non-brackets (no backtracking)\\n  |             # Or\\n  (?R)          # Recurse - i.e. nested bracketed string\\n  )*            # Zero or more contents\\n  \\)            # Closing )\\n  ")
  "(abcd"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/616: 
;;;
;;;    
;
(test-case/g
  "pcre-2/616"
  "\\(  ( (?>[^()]+) | (?R) )* \\) "
  "(ab(xy)cd)pqr"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/617: 
;;;
;;;    
;
(test-case/g
  "pcre-2/617"
  "\\(  ( (?>[^()]+) | (?R) )* \\) "
  "1(abcd)(x(y)z)pqr"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/620: 
;;;
;;;    
;
(test-case
  "pcre-2/620"
  "\\(  (?: (?>[^()]+) | (?R) ) \\) "
  "(abcd)"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/621: 
;;;
;;;    
;
(test-case
  "pcre-2/621"
  "\\(  (?: (?>[^()]+) | (?R) ) \\) "
  "(ab(xy)cd)"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/622: 
;;;
;;;    
;
(test-case
  "pcre-2/622"
  "\\(  (?: (?>[^()]+) | (?R) ) \\) "
  "(a(b(c)d)e)"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/623: 
;;;
;;;    
;
(test-case
  "pcre-2/623"
  "\\(  (?: (?>[^()]+) | (?R) ) \\) "
  "((ab))"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/624: 
;;;
;;;    
;
(test-case
  "pcre-2/624"
  "\\(  (?: (?>[^()]+) | (?R) ) \\) "
  "*** Failers"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/625: 
;;;
;;;    
;
(test-case
  "pcre-2/625"
  "\\(  (?: (?>[^()]+) | (?R) ) \\) "
  "()"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/628: 
;;;
;;;    
;
(test-case
  "pcre-2/628"
  "\\(  (?: (?>[^()]+) | (?R) )? \\) "
  "()"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/629: 
;;;
;;;    
;
(test-case
  "pcre-2/629"
  "\\(  (?: (?>[^()]+) | (?R) )? \\) "
  "12(abcde(fsh)xyz(foo(bar))lmno)89"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/632: 
;;;
;;;    
;
(test-case
  "pcre-2/632"
  "\\(  ( (?>[^()]+) | (?R) )* \\) "
  "(ab(xy)cd)"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/635: 
;;;
;;;    
;
(test-case
  "pcre-2/635"
  "\\( ( ( (?>[^()]+) | (?R) )* ) \\) "
  "(ab(xy)cd)"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/638: 
;;;
;;;    
;
(test-case
  "pcre-2/638"
  "\\( (123)? ( ( (?>[^()]+) | (?R) )* ) \\) "
  "(ab(xy)cd)"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/639: 
;;;
;;;    
;
(test-case
  "pcre-2/639"
  "\\( (123)? ( ( (?>[^()]+) | (?R) )* ) \\) "
  "(123ab(xy)cd)"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/642: 
;;;
;;;    
;
(test-case
  "pcre-2/642"
  "\\( ( (123)? ( (?>[^()]+) | (?R) )* ) \\) "
  "(ab(xy)cd)"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/643: 
;;;
;;;    
;
(test-case
  "pcre-2/643"
  "\\( ( (123)? ( (?>[^()]+) | (?R) )* ) \\) "
  "(123ab(xy)cd)"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/646: 
;;;
;;;    
;
(test-case
  "pcre-2/646"
  "\\( (((((((((( ( (?>[^()]+) | (?R) )* )))))))))) \\) "
  "(ab(xy)cd)"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/649: 
;;;
;;;    
;
(test-case
  "pcre-2/649"
  "\\( ( ( (?>[^()<>]+) | ((?>[^()]+)) | (?R) )* ) \\) "
  "(abcd(xyz<p>qrs)123)"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/652: 
;;;
;;;    
;
(test-case
  "pcre-2/652"
  "\\( ( ( (?>[^()]+) | ((?R)) )* ) \\) "
  "(ab(cd)ef)"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/653: 
;;;
;;;    
;
(test-case
  "pcre-2/653"
  "\\( ( ( (?>[^()]+) | ((?R)) )* ) \\) "
  "(ab(cd(ef)gh)ij)"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/698: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/698"
  "[[:upper:]]"
  "A"
  '(:ignore-case t :single-line nil)
  (list "A") )

;;;; testinput2/699: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/699"
  "[[:upper:]]"
  "a"
  '(:ignore-case t :single-line nil)
  (list "a") )

;;;; testinput2/702: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/702"
  "[[:lower:]]"
  "A"
  '(:ignore-case t :single-line nil)
  (list "A") )

;;;; testinput2/703: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/703"
  "[[:lower:]]"
  "a"
  '(:ignore-case t :single-line nil)
  (list "a") )

;;;; testinput2/706: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-2/706"
  "((?-i)[[:lower:]])[[:lower:]]"
  "ab"
  '(:ignore-case t :single-line nil)
  (list
    "ab"
    "a" ) )

;;;; testinput2/707: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-2/707"
  "((?-i)[[:lower:]])[[:lower:]]"
  "aB"
  '(:ignore-case t :single-line nil)
  (list
    "aB"
    "a" ) )

;;;; testinput2/708: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-2/708"
  "((?-i)[[:lower:]])[[:lower:]]"
  "*** Failers"
  '(:ignore-case t :single-line nil)
  (list
    "ai"
    "a" ) )

;;;; testinput2/709: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/709"
  "((?-i)[[:lower:]])[[:lower:]]"
  "Ab"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput2/710: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/710"
  "((?-i)[[:lower:]])[[:lower:]]"
  "AB"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput2/719: 
;;;
;;;    Matched with 271 captures.
; Too many captures for test driver.
;;;; testinput2/724: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-2/724"
  "(main(O)?)+"
  "mainmain"
  '(:single-line nil)
  (list
    "mainmain"
    "main"
    nil ) )

;;;; testinput2/725: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-2/725"
  "(main(O)?)+"
  "mainOmain"
  '(:single-line nil)
  (list
    "mainOmain"
    "main"
    nil ) )

;;;; testinput2/730: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-2/730"
  "^(a(b)?)+$"
  "aba"
  '(:single-line nil)
  (list
    "aba"
    "a"
    nil ) )

;;;; testinput2/733: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-2/733"
  "^(aa(bb)?)+$"
  "aabbaa"
  '(:single-line nil)
  (list
    "aabbaa"
    "aa"
    nil ) )

;;;; testinput2/736: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-2/736"
  "^(aa|aa(bb))+$"
  "aabbaa"
  '(:single-line nil)
  (list
    "aabbaa"
    "aa"
    "bb" ) )

;;;; testinput2/739: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-2/739"
  "^(aa(bb)??)+$"
  "aabbaa"
  '(:single-line nil)
  (list
    "aabbaa"
    "aa"
    nil ) )

;;;; testinput2/742: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-2/742"
  "^(?:aa(bb)?)+$"
  "aabbaa"
  '(:single-line nil)
  (list
    "aabbaa"
    nil ) )

;;;; testinput2/745: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-2/745"
  "^(aa(b(b))?)+$"
  "aabbaa"
  '(:single-line nil)
  (list
    "aabbaa"
    "aa"
    "bb"
    "b" ) )

;;;; testinput2/748: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-2/748"
  "^(?:aa(b(b))?)+$"
  "aabbaa"
  '(:single-line nil)
  (list
    "aabbaa"
    "bb"
    "b" ) )

;;;; testinput2/751: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-2/751"
  "^(?:aa(b(?:b))?)+$"
  "aabbaa"
  '(:single-line nil)
  (list
    "aabbaa"
    nil ) )

;;;; testinput2/754: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-2/754"
  "^(?:aa(bb(?:b))?)+$"
  "aabbbaa"
  '(:single-line nil)
  (list
    "aabbbaa"
    nil ) )

;;;; testinput2/757: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-2/757"
  "^(?:aa(b(?:bb))?)+$"
  "aabbbaa"
  '(:single-line nil)
  (list
    "aabbbaa"
    nil ) )

;;;; testinput2/760: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-2/760"
  "^(?:aa(?:b(b))?)+$"
  "aabbaa"
  '(:single-line nil)
  (list
    "aabbaa"
    "b" ) )

;;;; testinput2/763: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-2/763"
  "^(?:aa(?:b(bb))?)+$"
  "aabbbaa"
  '(:single-line nil)
  (list
    "aabbbaa"
    "bb" ) )

;;;; testinput2/766: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-2/766"
  "^(aa(b(bb))?)+$"
  "aabbbaa"
  '(:single-line nil)
  (list
    "aabbbaa"
    "aa"
    "bbb"
    "bb" ) )

;;;; testinput2/769: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-2/769"
  "^(aa(bb(bb))?)+$"
  "aabbbbaa"
  '(:single-line nil)
  (list
    "aabbbbaa"
    "aa"
    "bbbb"
    "bb" ) )

;;;; testinput2/782: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/782"
  "a(?i)b"
  "ab"
  '(:single-line nil)
  (list "ab") )

;;;; testinput2/783: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/783"
  "a(?i)b"
  "aB"
  '(:single-line nil)
  (list "aB") )

;;;; testinput2/784: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/784"
  "a(?i)b"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput2/785: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/785"
  "a(?i)b"
  "AB"
  '(:single-line nil)
  nil
 )

;;;; testinput2/788: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-2/788"
  "(a(?i)b)"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "ab" ) )

;;;; testinput2/789: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-2/789"
  "(a(?i)b)"
  "aB"
  '(:single-line nil)
  (list
    "aB"
    "aB" ) )

;;;; testinput2/790: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/790"
  "(a(?i)b)"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput2/791: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/791"
  "(a(?i)b)"
  "AB"
  '(:single-line nil)
  nil
 )

;;;; testinput2/803: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/803"
  "\\Q\\E"
  ""
  '(:single-line nil)
  nil
 )

;;;; testinput2/810: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/810"
  "a\\Q\\E"
  "abc"
  '(:single-line nil)
  (list "a") )

;;;; testinput2/811: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/811"
  "a\\Q\\E"
  "bca"
  '(:single-line nil)
  (list "a") )

;;;; testinput2/812: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/812"
  "a\\Q\\E"
  "bac"
  '(:single-line nil)
  (list "a") )

;;;; testinput2/815: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/815"
  "a\\Q\\Eb"
  "abc"
  '(:single-line nil)
  (list "ab") )

;;;; testinput2/820: 
;;;
;;;    
;
(test-case
  "pcre-2/820"
  "x*+\\w"
  "*** Failers"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/821: 
;;;
;;;    
;
(test-case
  "pcre-2/821"
  "x*+\\w"
  "xxxxx"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/832: 
;;;
;;;    
;
(test-case
  "pcre-2/832"
  "^(\\w++|\\s++)*$"
  "now is the time for all good men to come to the aid of the party"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/833: 
;;;
;;;    
;
(test-case
  "pcre-2/833"
  "^(\\w++|\\s++)*$"
  "*** Failers"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/834: 
;;;
;;;    
;
(test-case
  "pcre-2/834"
  "^(\\w++|\\s++)*$"
  "this is not a line with only words and spaces!"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/837: 
;;;
;;;    
;
(test-case
  "pcre-2/837"
  "(\\d++)(\\w)"
  "12345a"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/838: 
;;;
;;;    
;
(test-case
  "pcre-2/838"
  "(\\d++)(\\w)"
  "*** Failers"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/839: 
;;;
;;;    
;
(test-case
  "pcre-2/839"
  "(\\d++)(\\w)"
  "12345+"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/842: 
;;;
;;;    
;
(test-case
  "pcre-2/842"
  "a++b"
  "aaab"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/845: 
;;;
;;;    
;
(test-case
  "pcre-2/845"
  "(a++b)"
  "aaab"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/848: 
;;;
;;;    
;
(test-case
  "pcre-2/848"
  "(a++)b"
  "aaab"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/851: 
;;;
;;;    
;
(test-case
  "pcre-2/851"
  "([^()]++|\\([^()]*\\))+"
  "((abc(ade)ufh()()x"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/854: 
;;;
;;;    
;
(test-case
  "pcre-2/854"
  "\\(([^()]++|\\([^()]+\\))+\\)"
  "(abc)"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/855: 
;;;
;;;    
;
(test-case
  "pcre-2/855"
  "\\(([^()]++|\\([^()]+\\))+\\)"
  "(abc(def)xyz)"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/856: 
;;;
;;;    
;
(test-case
  "pcre-2/856"
  "\\(([^()]++|\\([^()]+\\))+\\)"
  "*** Failers"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/857: 
;;;
;;;    
;
(test-case
  "pcre-2/857"
  "\\(([^()]++|\\([^()]+\\))+\\)"
  "((()aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/870: 
;;;
;;;    
;
(test-case
  "pcre-2/870"
  "x(?U)a++b"
  "xaaaab"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/873: 
;;;
;;;    
;
(test-case
  "pcre-2/873"
  "(?U)xa++b"
  "xaaaab"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/920: 
;;;
;;;    
;
(test-case
  "pcre-2/920"
  "< (?: (?(R) \\d++  | [^<>]*+) | (?R)) * >"
  "<>"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/921: 
;;;
;;;    
;
(test-case
  "pcre-2/921"
  "< (?: (?(R) \\d++  | [^<>]*+) | (?R)) * >"
  "<abcd>"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/922: 
;;;
;;;    
;
(test-case
  "pcre-2/922"
  "< (?: (?(R) \\d++  | [^<>]*+) | (?R)) * >"
  "<abc <123> hij>"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/923: 
;;;
;;;    
;
(test-case
  "pcre-2/923"
  "< (?: (?(R) \\d++  | [^<>]*+) | (?R)) * >"
  "<abc <def> hij>"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/924: 
;;;
;;;    
;
(test-case
  "pcre-2/924"
  "< (?: (?(R) \\d++  | [^<>]*+) | (?R)) * >"
  "<abc<>def>"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/925: 
;;;
;;;    
;
(test-case
  "pcre-2/925"
  "< (?: (?(R) \\d++  | [^<>]*+) | (?R)) * >"
  "<abc<>"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/926: 
;;;
;;;    
;
(test-case
  "pcre-2/926"
  "< (?: (?(R) \\d++  | [^<>]*+) | (?R)) * >"
  "*** Failers"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/927: 
;;;
;;;    
;
(test-case
  "pcre-2/927"
  "< (?: (?(R) \\d++  | [^<>]*+) | (?R)) * >"
  "<abc"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/944: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-2/944"
  "((.*))\\d+\\1"
  "abc123bc"
  '(:single-line nil)
  (list
    "bc123bc"
    "bc"
    "bc" ) )

;;;; testinput2/993: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/993"
  "^a"
  "abcde"
  '(:multiple-lines t :single-line nil)
  (list "a") )

;;;; testinput2/994: 
;;;
;;;    Matched
;
(test-case
  "pcre-2/994"
  "^a"
  (backslash "xy\\nabc")
  '(:multiple-lines t :single-line nil)
  (list "a") )

;;;; testinput2/995: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/995"
  "^a"
  "*** Failers"
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput2/996: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/996"
  "^a"
  "xyabc"
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput2/1005: 
;;;
;;;    
;
(test-case
  "pcre-2/1005"
  "abc(?C)def"
  "abcdef"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1006: 
;;;
;;;    
;
(test-case
  "pcre-2/1006"
  "abc(?C)def"
  "1234abcdef"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1007: 
;;;
;;;    
;
(test-case
  "pcre-2/1007"
  "abc(?C)def"
  "*** Failers"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1008: 
;;;
;;;    
;
(test-case
  "pcre-2/1008"
  "abc(?C)def"
  "abcxyz"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1009: 
;;;
;;;    
;
(test-case
  "pcre-2/1009"
  "abc(?C)def"
  "abcxyzf"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1012: 
;;;
;;;    
;
(test-case
  "pcre-2/1012"
  "abc(?C)de(?C1)f"
  "123abcdef"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1015: 
;;;
;;;    
;
(test-case
  "pcre-2/1015"
  "(?C1)\\dabc(?C2)def"
  "1234abcdef"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1016: 
;;;
;;;    
;
(test-case
  "pcre-2/1016"
  "(?C1)\\dabc(?C2)def"
  "*** Failers"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1017: 
;;;
;;;    
;
(test-case
  "pcre-2/1017"
  "(?C1)\\dabc(?C2)def"
  "abcdef"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1028: 
;;;
;;;    
;
(test-case
  "pcre-2/1028"
  "abc(?C)def"
  "*** Failers"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1029: 
;;;
;;;    
;
(test-case
  "pcre-2/1029"
  "abc(?C)def"
  (backslash "\\u0083\\u0000abcdef")
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1032: 
;;;
;;;    
;
(test-case
  "pcre-2/1032"
  "(abc)(?C)de(?C1)f"
  "123abcdef"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1033: 
;;;
;;;    
;
(test-case
  "pcre-2/1033"
  "(abc)(?C)de(?C1)f"
  "123abcdefC+"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1034: 
;;;
;;;    
;
(test-case
  "pcre-2/1034"
  "(abc)(?C)de(?C1)f"
  "123abcdefC-"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1035: 
;;;
;;;    
;
(test-case
  "pcre-2/1035"
  "(abc)(?C)de(?C1)f"
  "*** Failers"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1036: 
;;;
;;;    
;
(test-case
  "pcre-2/1036"
  "(abc)(?C)de(?C1)f"
  "123abcdefC!1"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1039: 
;;;
;;;    
;
(test-case
  "pcre-2/1039"
  "(?C0)(abc(?C1))*"
  "abcabcabc"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1040: 
;;;
;;;    
;
(test-case
  "pcre-2/1040"
  "(?C0)(abc(?C1))*"
  "abcabcC!1!3"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1041: 
;;;
;;;    
;
(test-case
  "pcre-2/1041"
  "(?C0)(abc(?C1))*"
  "*** Failers"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1042: 
;;;
;;;    
;
(test-case
  "pcre-2/1042"
  "(?C0)(abc(?C1))*"
  "abcabcabcC!1!3"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1045: 
;;;
;;;    
;
(test-case
  "pcre-2/1045"
  "(\\d{3}(?C))*"
  "123C+"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1046: 
;;;
;;;    
;
(test-case
  "pcre-2/1046"
  "(\\d{3}(?C))*"
  "123456C+"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1047: 
;;;
;;;    
;
(test-case
  "pcre-2/1047"
  "(\\d{3}(?C))*"
  "123456789C+"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1050: 
;;;
;;;    
;
(test-case
  "pcre-2/1050"
  "((xyz)(?C)p|(?C1)xyzabc)"
  "xyzabcC+"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1053: 
;;;
;;;    
;
(test-case
  "pcre-2/1053"
  "(X)((xyz)(?C)p|(?C1)xyzabc)"
  "XxyzabcC+"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1056: 
;;;
;;;    
;
(test-case
  "pcre-2/1056"
  "(?=(abc))(?C)abcdef"
  "abcdefC+"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1059: 
;;;
;;;    
;
(test-case
  "pcre-2/1059"
  "(?!(abc)(?C1)d)(?C2)abcxyz"
  "abcxyzC+"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1062: 
;;;
;;;    
;
(test-case
  "pcre-2/1062"
  "(?<=(abc)(?C))xyz"
  "abcxyzC+"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1077: 
;;;
;;;    
;
(test-case
  "pcre-2/1077"
  "x(ab|(bc|(de|(?R))))"
  "xab"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1078: 
;;;
;;;    
;
(test-case
  "pcre-2/1078"
  "x(ab|(bc|(de|(?R))))"
  "xbc"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1079: 
;;;
;;;    
;
(test-case
  "pcre-2/1079"
  "x(ab|(bc|(de|(?R))))"
  "xde"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1080: 
;;;
;;;    
;
(test-case
  "pcre-2/1080"
  "x(ab|(bc|(de|(?R))))"
  "xxab"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1081: 
;;;
;;;    
;
(test-case
  "pcre-2/1081"
  "x(ab|(bc|(de|(?R))))"
  "xxxab"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1082: 
;;;
;;;    
;
(test-case
  "pcre-2/1082"
  "x(ab|(bc|(de|(?R))))"
  "*** Failers"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1083: 
;;;
;;;    
;
(test-case
  "pcre-2/1083"
  "x(ab|(bc|(de|(?R))))"
  "xyab"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1090: 
;;;
;;;    
;
(test-case
  "pcre-2/1090"
  "^([^()]|\\((?1)*\\))*$"
  "abc"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1091: 
;;;
;;;    
;
(test-case
  "pcre-2/1091"
  "^([^()]|\\((?1)*\\))*$"
  "a(b)c"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1092: 
;;;
;;;    
;
(test-case
  "pcre-2/1092"
  "^([^()]|\\((?1)*\\))*$"
  "a(b(c))d"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1093: 
;;;
;;;    
;
(test-case
  "pcre-2/1093"
  "^([^()]|\\((?1)*\\))*$"
  "*** Failers)"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1094: 
;;;
;;;    
;
(test-case
  "pcre-2/1094"
  "^([^()]|\\((?1)*\\))*$"
  "a(b(c)d"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1097: 
;;;
;;;    
;
(test-case
  "pcre-2/1097"
  "^>abc>([^()]|\\((?1)*\\))*<xyz<$"
  ">abc>123<xyz<"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1098: 
;;;
;;;    
;
(test-case
  "pcre-2/1098"
  "^>abc>([^()]|\\((?1)*\\))*<xyz<$"
  ">abc>1(2)3<xyz<"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1099: 
;;;
;;;    
;
(test-case
  "pcre-2/1099"
  "^>abc>([^()]|\\((?1)*\\))*<xyz<$"
  ">abc>(1(2)3)<xyz<"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1106: 
;;;
;;;    
;
(test-case
  "pcre-2/1106"
  "^\\W*(?:((.)\\W*(?1)\\W*\\2|)|((.)\\W*(?3)\\W*\\4|\\W*.\\W*))\\W*$"
  "1221"
  '(:ignore-case t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1107: 
;;;
;;;    
;
(test-case
  "pcre-2/1107"
  "^\\W*(?:((.)\\W*(?1)\\W*\\2|)|((.)\\W*(?3)\\W*\\4|\\W*.\\W*))\\W*$"
  "Satan, oscillate my metallic sonatas!"
  '(:ignore-case t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1108: 
;;;
;;;    
;
(test-case
  "pcre-2/1108"
  "^\\W*(?:((.)\\W*(?1)\\W*\\2|)|((.)\\W*(?3)\\W*\\4|\\W*.\\W*))\\W*$"
  "A man, a plan, a canal: Panama!"
  '(:ignore-case t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1109: 
;;;
;;;    
;
(test-case
  "pcre-2/1109"
  "^\\W*(?:((.)\\W*(?1)\\W*\\2|)|((.)\\W*(?3)\\W*\\4|\\W*.\\W*))\\W*$"
  "Able was I ere I saw Elba."
  '(:ignore-case t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1110: 
;;;
;;;    
;
(test-case
  "pcre-2/1110"
  "^\\W*(?:((.)\\W*(?1)\\W*\\2|)|((.)\\W*(?3)\\W*\\4|\\W*.\\W*))\\W*$"
  "*** Failers"
  '(:ignore-case t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1111: 
;;;
;;;    
;
(test-case
  "pcre-2/1111"
  "^\\W*(?:((.)\\W*(?1)\\W*\\2|)|((.)\\W*(?3)\\W*\\4|\\W*.\\W*))\\W*$"
  "The quick brown fox"
  '(:ignore-case t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1114: 
;;;
;;;    
;
(test-case
  "pcre-2/1114"
  "^(\\d+|\\((?1)([+*-])(?1)\\)|-(?1))$"
  "12"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1115: 
;;;
;;;    
;
(test-case
  "pcre-2/1115"
  "^(\\d+|\\((?1)([+*-])(?1)\\)|-(?1))$"
  "(((2+2)*-3)-7)"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1116: 
;;;
;;;    
;
(test-case
  "pcre-2/1116"
  "^(\\d+|\\((?1)([+*-])(?1)\\)|-(?1))$"
  "-12"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1117: 
;;;
;;;    
;
(test-case
  "pcre-2/1117"
  "^(\\d+|\\((?1)([+*-])(?1)\\)|-(?1))$"
  "*** Failers"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1118: 
;;;
;;;    
;
(test-case
  "pcre-2/1118"
  "^(\\d+|\\((?1)([+*-])(?1)\\)|-(?1))$"
  "((2+2)*-3)-7)"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1121: 
;;;
;;;    
;
(test-case
  "pcre-2/1121"
  "^(x(y|(?1){2})z)"
  "xyz"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1122: 
;;;
;;;    
;
(test-case
  "pcre-2/1122"
  "^(x(y|(?1){2})z)"
  "xxyzxyzz"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1123: 
;;;
;;;    
;
(test-case
  "pcre-2/1123"
  "^(x(y|(?1){2})z)"
  "*** Failers"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1124: 
;;;
;;;    
;
(test-case
  "pcre-2/1124"
  "^(x(y|(?1){2})z)"
  "xxyzz"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1125: 
;;;
;;;    
;
(test-case
  "pcre-2/1125"
  "^(x(y|(?1){2})z)"
  "xxyzxyzxyzz"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1128: 
;;;
;;;    
;
(test-case
  "pcre-2/1128"
  "((< (?: (?(R) \\d++  | [^<>]*+) | (?2)) * >))"
  "<>"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1129: 
;;;
;;;    
;
(test-case
  "pcre-2/1129"
  "((< (?: (?(R) \\d++  | [^<>]*+) | (?2)) * >))"
  "<abcd>"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1130: 
;;;
;;;    
;
(test-case
  "pcre-2/1130"
  "((< (?: (?(R) \\d++  | [^<>]*+) | (?2)) * >))"
  "<abc <123> hij>"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1131: 
;;;
;;;    
;
(test-case
  "pcre-2/1131"
  "((< (?: (?(R) \\d++  | [^<>]*+) | (?2)) * >))"
  "<abc <def> hij>"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1132: 
;;;
;;;    
;
(test-case
  "pcre-2/1132"
  "((< (?: (?(R) \\d++  | [^<>]*+) | (?2)) * >))"
  "<abc<>def>"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1133: 
;;;
;;;    
;
(test-case
  "pcre-2/1133"
  "((< (?: (?(R) \\d++  | [^<>]*+) | (?2)) * >))"
  "<abc<>"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1134: 
;;;
;;;    
;
(test-case
  "pcre-2/1134"
  "((< (?: (?(R) \\d++  | [^<>]*+) | (?2)) * >))"
  "*** Failers"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1135: 
;;;
;;;    
;
(test-case
  "pcre-2/1135"
  "((< (?: (?(R) \\d++  | [^<>]*+) | (?2)) * >))"
  "<abc"
  '(:extended-syntax t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1142: 
;;;
;;;    
;
(test-case
  "pcre-2/1142"
  "^(abc)def(?1)"
  "abcdefabc"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1145: 
;;;
;;;    
;
(test-case
  "pcre-2/1145"
  "^(a|b|c)=(?1)+"
  "a=a"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1146: 
;;;
;;;    
;
(test-case
  "pcre-2/1146"
  "^(a|b|c)=(?1)+"
  "a=b"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1147: 
;;;
;;;    
;
(test-case
  "pcre-2/1147"
  "^(a|b|c)=(?1)+"
  "a=bc"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1150: 
;;;
;;;    
;
(test-case
  "pcre-2/1150"
  "^(a|b|c)=((?1))+"
  "a=a"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1151: 
;;;
;;;    
;
(test-case
  "pcre-2/1151"
  "^(a|b|c)=((?1))+"
  "a=b"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1152: 
;;;
;;;    
;
(test-case
  "pcre-2/1152"
  "^(a|b|c)=((?1))+"
  "a=bc"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1155: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-2/1155"
  "a(?<name1>b|c)d(?<longername2>e)"
  "abde"
  '(:single-line nil)
  (list
    "abde"
    "b"
    "e" ) )

;;;; testinput2/1156: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-2/1156"
  "a(?<name1>b|c)d(?<longername2>e)"
  "acde"
  '(:single-line nil)
  (list
    "acde"
    "c"
    "e" ) )

;;;; testinput2/1163: 
;;;
;;;    
;
(test-case
  "pcre-2/1163"
  "^\\W*(?:(?<one>(?<two>.)\\W*(?P>one)\\W*\\k<two>|)|(?<three>(?<four>.)\\W*(?P>three)\\W*\\k<four>|\\W*.\\W*))\\W*$"
  "1221"
  '(:ignore-case t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1164: 
;;;
;;;    
;
(test-case
  "pcre-2/1164"
  "^\\W*(?:(?<one>(?<two>.)\\W*(?P>one)\\W*\\k<two>|)|(?<three>(?<four>.)\\W*(?P>three)\\W*\\k<four>|\\W*.\\W*))\\W*$"
  "Satan, oscillate my metallic sonatas!"
  '(:ignore-case t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1165: 
;;;
;;;    
;
(test-case
  "pcre-2/1165"
  "^\\W*(?:(?<one>(?<two>.)\\W*(?P>one)\\W*\\k<two>|)|(?<three>(?<four>.)\\W*(?P>three)\\W*\\k<four>|\\W*.\\W*))\\W*$"
  "A man, a plan, a canal: Panama!"
  '(:ignore-case t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1166: 
;;;
;;;    
;
(test-case
  "pcre-2/1166"
  "^\\W*(?:(?<one>(?<two>.)\\W*(?P>one)\\W*\\k<two>|)|(?<three>(?<four>.)\\W*(?P>three)\\W*\\k<four>|\\W*.\\W*))\\W*$"
  "Able was I ere I saw Elba."
  '(:ignore-case t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1167: 
;;;
;;;    
;
(test-case
  "pcre-2/1167"
  "^\\W*(?:(?<one>(?<two>.)\\W*(?P>one)\\W*\\k<two>|)|(?<three>(?<four>.)\\W*(?P>three)\\W*\\k<four>|\\W*.\\W*))\\W*$"
  "*** Failers"
  '(:ignore-case t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1168: 
;;;
;;;    
;
(test-case
  "pcre-2/1168"
  "^\\W*(?:(?<one>(?<two>.)\\W*(?P>one)\\W*\\k<two>|)|(?<three>(?<four>.)\\W*(?P>three)\\W*\\k<four>|\\W*.\\W*))\\W*$"
  "The quick brown fox"
  '(:ignore-case t :single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1171: 
;;;
;;;    
;
(test-case
  "pcre-2/1171"
  "((?(R)a|b))\\1(?1)?"
  "bb"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1172: 
;;;
;;;    
;
(test-case
  "pcre-2/1172"
  "((?(R)a|b))\\1(?1)?"
  "bbaa"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1197: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-2/1197"
  "(a)(bc)"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "a"
    "bc" ) )

;;;; testinput2/1200: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-2/1200"
  "(?<one>a)(bc)"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "a"
    "bc" ) )

;;;; testinput2/1205: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-2/1205"
  "(a+)*zz"
  "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaazzbbbbbbM"
  '(:single-line nil)
  (list
    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaazz"
    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" ) )

;;;; testinput2/1206: 
;;;
;;;    Not matched
;
(test-case
  "pcre-2/1206"
  "(a+)*zz"
  "aaaaaaaaaaaaazM"
  '(:single-line nil)
  nil
 )

;;;; testinput2/1209: 
;;;
;;;    
;
(test-case
  "pcre-2/1209"
  "(aaa(?C1)bbb|ab)"
  "aaabbb"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1210: 
;;;
;;;    
;
(test-case
  "pcre-2/1210"
  "(aaa(?C1)bbb|ab)"
  "aaabbbC*0"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1211: 
;;;
;;;    
;
(test-case
  "pcre-2/1211"
  "(aaa(?C1)bbb|ab)"
  "aaabbbC*1"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1212: 
;;;
;;;    
;
(test-case
  "pcre-2/1212"
  "(aaa(?C1)bbb|ab)"
  "aaabbbC*-1"
  '(:single-line nil)
   :compile  ; Perl failed to compile.
 )

;;;; testinput2/1215: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-2/1215"
  "ab(?<one>cd)ef(?<two>gh)"
  "abcdefgh"
  '(:single-line nil)
  (list
    "abcdefgh"
    "cd"
    "gh" ) )

;;;; testinput2/1216: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-2/1216"
  "ab(?<one>cd)ef(?<two>gh)"
  "abcdefghC1Gtwo"
  '(:single-line nil)
  (list
    "abcdefgh"
    "cd"
    "gh" ) )

;;;; testinput2/1217: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-2/1217"
  "ab(?<one>cd)ef(?<two>gh)"
  "abcdefghConeCtwo"
  '(:single-line nil)
  (list
    "abcdefgh"
    "cd"
    "gh" ) )

;;;; testinput2/1218: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-2/1218"
  "ab(?<one>cd)ef(?<two>gh)"
  "abcdefghCthree"
  '(:single-line nil)
  (list
    "abcdefgh"
    "cd"
    "gh" ) )

;;;; testinput2/1225: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-2/1225"
  "(?<Z>zz)(?<A>aa)"
  "zzaaCZ"
  '(:single-line nil)
  (list
    "zzaa"
    "zz"
    "aa" ) )

;;;; testinput2/1226: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-2/1226"
  "(?<Z>zz)(?<A>aa)"
  "zzaaCA"
  '(:single-line nil)
  (list
    "zzaa"
    "zz"
    "aa" ) )

; EOF
